From aa5785710a82dc98c878ed1bc8b8192c854cc091 Mon Sep 17 00:00:00 2001 From: Soren Sandmann Date: Sun, 4 Feb 2007 01:28:38 +0000 Subject: [PATCH] Remove these files since GSequence has been moved into GLib. 2007-02-03 Soren Sandmann * gtk/gtksequence.[ch]: Remove these files since GSequence has been moved into GLib. * gtk/gtkliststore.c: Port to GSequence instead of GtkSequence. * configure.in: Require glib-2.13.0 svn path=/trunk/; revision=17259 --- ChangeLog | 9 + configure.in | 2 +- gtk/Makefile.am | 2 - gtk/gtkliststore.c | 193 ++++---- gtk/gtksequence.c | 1143 -------------------------------------------- gtk/gtksequence.h | 104 ---- 6 files changed, 106 insertions(+), 1347 deletions(-) delete mode 100644 gtk/gtksequence.c delete mode 100644 gtk/gtksequence.h diff --git a/ChangeLog b/ChangeLog index 98c3b2b1a5..4ef53b474d 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,12 @@ +2007-02-03 Soren Sandmann + + * gtk/gtksequence.[ch]: Remove these files since GSequence has + been moved into GLib. + + * gtk/gtkliststore.c: Port to GSequence instead of GtkSequence. + + * configure.in: Require glib-2.13.0 + 2007-02-04 Tor Lillqvist * gdk/win32/gdkcursor-win32.c: Don't define BITMAPV5HEADER on diff --git a/configure.in b/configure.in index 69f012199e..d57fe21bff 100644 --- a/configure.in +++ b/configure.in @@ -31,7 +31,7 @@ m4_define([gtk_api_version], [2.0]) m4_define([gtk_binary_version], [2.10.0]) # required versions of other packages -m4_define([glib_required_version], [2.12.0]) +m4_define([glib_required_version], [2.13.0]) m4_define([pango_required_version], [1.15.3]) m4_define([atk_required_version], [1.9.0]) m4_define([cairo_required_version], [1.2.0]) diff --git a/gtk/Makefile.am b/gtk/Makefile.am index 297a49b42a..749b7ff8f5 100644 --- a/gtk/Makefile.am +++ b/gtk/Makefile.am @@ -355,7 +355,6 @@ gtk_private_h_sources = \ gtkrecentchooserdefault.h \ gtkrecentchooserprivate.h \ gtkrecentchooserutils.h \ - gtksequence.h \ gtksocketprivate.h \ gtktextbtree.h \ gtktextbufferserialize.h\ @@ -525,7 +524,6 @@ gtk_base_c_sources = \ gtkseparator.c \ gtkseparatormenuitem.c \ gtkseparatortoolitem.c \ - gtksequence.c \ gtksettings.c \ gtksignal.c \ gtksizegroup.c \ diff --git a/gtk/gtkliststore.c b/gtk/gtkliststore.c index 97f054ba3f..e095b05cc7 100644 --- a/gtk/gtkliststore.c +++ b/gtk/gtkliststore.c @@ -24,12 +24,11 @@ #include "gtkliststore.h" #include "gtktreedatalist.h" #include "gtktreednd.h" -#include "gtksequence.h" #include "gtkintl.h" #include "gtkalias.h" #define GTK_LIST_STORE_IS_SORTED(list) (((GtkListStore*)(list))->sort_column_id != GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID) -#define VALID_ITER(iter, list_store) ((iter)!= NULL && (iter)->user_data != NULL && list_store->stamp == (iter)->stamp && !_gtk_sequence_ptr_is_end ((iter)->user_data) && _gtk_sequence_ptr_get_sequence ((iter)->user_data) == list_store->seq) +#define VALID_ITER(iter, list_store) ((iter)!= NULL && (iter)->user_data != NULL && list_store->stamp == (iter)->stamp && !g_sequence_iter_is_end ((iter)->user_data) && g_sequence_iter_get_sequence ((iter)->user_data) == list_store->seq) static void gtk_list_store_tree_model_init (GtkTreeModelIface *iface); static void gtk_list_store_drag_source_init(GtkTreeDragSourceIface *iface); @@ -180,7 +179,7 @@ gtk_list_store_sortable_init (GtkTreeSortableIface *iface) static void gtk_list_store_init (GtkListStore *list_store) { - list_store->seq = _gtk_sequence_new (NULL); + list_store->seq = g_sequence_new (NULL); list_store->sort_list = NULL; list_store->stamp = g_random_int (); list_store->sort_column_id = -2; @@ -295,7 +294,7 @@ gtk_list_store_set_column_types (GtkListStore *list_store, g_return_if_fail (list_store->columns_dirty == 0); gtk_list_store_set_n_columns (list_store, n_columns); - for (i = 0; i < n_columns; i++) + for (i = 0; i < n_columns; i++) { if (! _gtk_tree_data_list_check_type (types[i])) { @@ -355,10 +354,10 @@ gtk_list_store_finalize (GObject *object) { GtkListStore *list_store = GTK_LIST_STORE (object); - _gtk_sequence_foreach (list_store->seq, - (GFunc) _gtk_tree_data_list_free, list_store->column_headers); + g_sequence_foreach (list_store->seq, + (GFunc) _gtk_tree_data_list_free, list_store->column_headers); - _gtk_sequence_free (list_store->seq); + g_sequence_free (list_store->seq); _gtk_tree_data_list_header_free (list_store->sort_list); g_free (list_store->column_headers); @@ -413,7 +412,7 @@ gtk_list_store_get_iter (GtkTreeModel *tree_model, GtkTreePath *path) { GtkListStore *list_store = (GtkListStore *) tree_model; - GtkSequence *seq; + GSequence *seq; gint i; list_store->columns_dirty = TRUE; @@ -422,11 +421,11 @@ gtk_list_store_get_iter (GtkTreeModel *tree_model, i = gtk_tree_path_get_indices (path)[0]; - if (i >= _gtk_sequence_get_length (seq)) + if (i >= g_sequence_get_length (seq)) return FALSE; iter->stamp = list_store->stamp; - iter->user_data = _gtk_sequence_get_ptr_at_pos (seq, i); + iter->user_data = g_sequence_get_iter_at_pos (seq, i); return TRUE; } @@ -439,11 +438,11 @@ gtk_list_store_get_path (GtkTreeModel *tree_model, g_return_val_if_fail (iter->stamp == GTK_LIST_STORE (tree_model)->stamp, NULL); - if (_gtk_sequence_ptr_is_end (iter->user_data)) + if (g_sequence_iter_is_end (iter->user_data)) return NULL; path = gtk_tree_path_new (); - gtk_tree_path_append_index (path, _gtk_sequence_ptr_get_position (iter->user_data)); + gtk_tree_path_append_index (path, g_sequence_iter_get_position (iter->user_data)); return path; } @@ -461,7 +460,7 @@ gtk_list_store_get_value (GtkTreeModel *tree_model, g_return_if_fail (column < list_store->n_columns); g_return_if_fail (VALID_ITER (iter, list_store)); - list = _gtk_sequence_ptr_get_data (iter->user_data); + list = g_sequence_get (iter->user_data); while (tmp_column-- > 0 && list) list = list->next; @@ -479,9 +478,9 @@ gtk_list_store_iter_next (GtkTreeModel *tree_model, GtkTreeIter *iter) { g_return_val_if_fail (GTK_LIST_STORE (tree_model)->stamp == iter->stamp, FALSE); - iter->user_data = _gtk_sequence_ptr_next (iter->user_data); + iter->user_data = g_sequence_iter_next (iter->user_data); - return !_gtk_sequence_ptr_is_end (iter->user_data); + return !g_sequence_iter_is_end (iter->user_data); } static gboolean @@ -495,10 +494,10 @@ gtk_list_store_iter_children (GtkTreeModel *tree_model, if (parent) return FALSE; - if (_gtk_sequence_get_length (list_store->seq) > 0) + if (g_sequence_get_length (list_store->seq) > 0) { iter->stamp = list_store->stamp; - iter->user_data = _gtk_sequence_get_begin_ptr (list_store->seq); + iter->user_data = g_sequence_get_begin_iter (list_store->seq); return TRUE; } else @@ -519,7 +518,7 @@ gtk_list_store_iter_n_children (GtkTreeModel *tree_model, GtkListStore *list_store = (GtkListStore *) tree_model; if (iter == NULL) - return _gtk_sequence_get_length (list_store->seq); + return g_sequence_get_length (list_store->seq); g_return_val_if_fail (list_store->stamp == iter->stamp, -1); @@ -533,14 +532,14 @@ gtk_list_store_iter_nth_child (GtkTreeModel *tree_model, gint n) { GtkListStore *list_store = (GtkListStore *) tree_model; - GtkSequencePtr child; + GSequenceIter *child; if (parent) return FALSE; - child = _gtk_sequence_get_ptr_at_pos (list_store->seq, n); + child = g_sequence_get_iter_at_pos (list_store->seq, n); - if (_gtk_sequence_ptr_is_end (child)) + if (g_sequence_iter_is_end (child)) return FALSE; iter->stamp = list_store->stamp; @@ -594,7 +593,7 @@ gtk_list_store_real_set_value (GtkListStore *list_store, converted = TRUE; } - prev = list = _gtk_sequence_ptr_get_data (iter->user_data); + prev = list = g_sequence_get (iter->user_data); while (list != NULL) { @@ -617,10 +616,10 @@ gtk_list_store_real_set_value (GtkListStore *list_store, list = list->next; } - if (_gtk_sequence_ptr_get_data (iter->user_data) == NULL) + if (g_sequence_get (iter->user_data) == NULL) { list = _gtk_tree_data_list_alloc(); - _gtk_sequence_set (iter->user_data, list); + g_sequence_set (iter->user_data, list); list->next = NULL; } else @@ -848,7 +847,7 @@ gtk_list_store_remove (GtkListStore *list_store, GtkTreeIter *iter) { GtkTreePath *path; - GtkSequencePtr ptr, next; + GSequenceIter *ptr, *next; g_return_val_if_fail (GTK_IS_LIST_STORE (list_store), FALSE); g_return_val_if_fail (VALID_ITER (iter, list_store), FALSE); @@ -856,17 +855,17 @@ gtk_list_store_remove (GtkListStore *list_store, path = gtk_list_store_get_path (GTK_TREE_MODEL (list_store), iter); ptr = iter->user_data; - next = _gtk_sequence_ptr_next (ptr); + next = g_sequence_iter_next (ptr); - _gtk_tree_data_list_free (_gtk_sequence_ptr_get_data (ptr), list_store->column_headers); - _gtk_sequence_remove (iter->user_data); + _gtk_tree_data_list_free (g_sequence_get (ptr), list_store->column_headers); + g_sequence_remove (iter->user_data); list_store->length--; gtk_tree_model_row_deleted (GTK_TREE_MODEL (list_store), path); gtk_tree_path_free (path); - if (_gtk_sequence_ptr_is_end (next)) + if (g_sequence_iter_is_end (next)) { iter->stamp = 0; return FALSE; @@ -898,8 +897,8 @@ gtk_list_store_insert (GtkListStore *list_store, gint position) { GtkTreePath *path; - GtkSequence *seq; - GtkSequencePtr ptr; + GSequence *seq; + GSequenceIter *ptr; gint length; g_return_if_fail (GTK_IS_LIST_STORE (list_store)); @@ -910,12 +909,12 @@ gtk_list_store_insert (GtkListStore *list_store, seq = list_store->seq; - length = _gtk_sequence_get_length (seq); + length = g_sequence_get_length (seq); if (position > length) position = length; - ptr = _gtk_sequence_get_ptr_at_pos (seq, position); - ptr = _gtk_sequence_insert (ptr, NULL); + ptr = g_sequence_get_iter_at_pos (seq, position); + ptr = g_sequence_insert_before (ptr, NULL); iter->stamp = list_store->stamp; iter->user_data = ptr; @@ -947,7 +946,7 @@ gtk_list_store_insert_before (GtkListStore *list_store, GtkTreeIter *iter, GtkTreeIter *sibling) { - GtkSequencePtr after; + GSequenceIter *after; g_return_if_fail (GTK_IS_LIST_STORE (list_store)); g_return_if_fail (iter != NULL); @@ -955,11 +954,11 @@ gtk_list_store_insert_before (GtkListStore *list_store, g_return_if_fail (VALID_ITER (sibling, list_store)); if (!sibling) - after = _gtk_sequence_get_end_ptr (list_store->seq); + after = g_sequence_get_end_iter (list_store->seq); else after = sibling->user_data; - gtk_list_store_insert (list_store, iter, _gtk_sequence_ptr_get_position (after)); + gtk_list_store_insert (list_store, iter, g_sequence_iter_get_position (after)); } /** @@ -979,7 +978,7 @@ gtk_list_store_insert_after (GtkListStore *list_store, GtkTreeIter *iter, GtkTreeIter *sibling) { - GtkSequencePtr after; + GSequenceIter *after; g_return_if_fail (GTK_IS_LIST_STORE (list_store)); g_return_if_fail (iter != NULL); @@ -987,11 +986,11 @@ gtk_list_store_insert_after (GtkListStore *list_store, g_return_if_fail (VALID_ITER (sibling, list_store)); if (!sibling) - after = _gtk_sequence_get_begin_ptr (list_store->seq); + after = g_sequence_get_begin_iter (list_store->seq); else - after = _gtk_sequence_ptr_next (sibling->user_data); + after = g_sequence_iter_next (sibling->user_data); - gtk_list_store_insert (list_store, iter, _gtk_sequence_ptr_get_position (after)); + gtk_list_store_insert (list_store, iter, g_sequence_iter_get_position (after)); } /** @@ -1031,7 +1030,7 @@ gtk_list_store_append (GtkListStore *list_store, g_return_if_fail (GTK_IS_LIST_STORE (list_store)); g_return_if_fail (iter != NULL); - gtk_list_store_insert (list_store, iter, _gtk_sequence_get_length (list_store->seq)); + gtk_list_store_insert (list_store, iter, g_sequence_get_length (list_store->seq)); } static void @@ -1057,10 +1056,10 @@ gtk_list_store_clear (GtkListStore *list_store) GtkTreeIter iter; g_return_if_fail (GTK_IS_LIST_STORE (list_store)); - while (_gtk_sequence_get_length (list_store->seq) > 0) + while (g_sequence_get_length (list_store->seq) > 0) { iter.stamp = list_store->stamp; - iter.user_data = _gtk_sequence_get_begin_ptr (list_store->seq); + iter.user_data = g_sequence_get_begin_iter (list_store->seq); gtk_list_store_remove (list_store, &iter); } @@ -1091,7 +1090,7 @@ gtk_list_store_iter_is_valid (GtkListStore *list_store, if (!VALID_ITER (iter, list_store)) return FALSE; - if (_gtk_sequence_ptr_get_sequence (iter->user_data) != list_store->seq) + if (g_sequence_iter_get_sequence (iter->user_data) != list_store->seq) return FALSE; return TRUE; @@ -1205,7 +1204,7 @@ gtk_list_store_drag_data_received (GtkTreeDragDest *drag_dest, */ if (retval) { - GtkTreeDataList *dl = _gtk_sequence_ptr_get_data (src_iter.user_data); + GtkTreeDataList *dl = g_sequence_get (src_iter.user_data); GtkTreeDataList *copy_head = NULL; GtkTreeDataList *copy_prev = NULL; GtkTreeDataList *copy_iter = NULL; @@ -1231,7 +1230,7 @@ gtk_list_store_drag_data_received (GtkTreeDragDest *drag_dest, } dest_iter.stamp = list_store->stamp; - _gtk_sequence_set (dest_iter.user_data, copy_head); + g_sequence_set (dest_iter.user_data, copy_head); path = gtk_list_store_get_path (tree_model, &dest_iter); gtk_tree_model_row_changed (tree_model, path, &dest_iter); @@ -1282,7 +1281,7 @@ gtk_list_store_row_drop_possible (GtkTreeDragDest *drag_dest, indices = gtk_tree_path_get_indices (dest_path); - if (indices[0] <= _gtk_sequence_get_length (GTK_LIST_STORE (drag_dest)->seq)) + if (indices[0] <= g_sequence_get_length (GTK_LIST_STORE (drag_dest)->seq)) retval = TRUE; out: @@ -1330,30 +1329,30 @@ gtk_list_store_reorder (GtkListStore *store, gint i; GtkTreePath *path; GHashTable *new_positions; - GtkSequencePtr ptr; + GSequenceIter *ptr; gint *order; g_return_if_fail (GTK_IS_LIST_STORE (store)); g_return_if_fail (!GTK_LIST_STORE_IS_SORTED (store)); g_return_if_fail (new_order != NULL); - order = g_new (gint, _gtk_sequence_get_length (store->seq)); - for (i = 0; i < _gtk_sequence_get_length (store->seq); i++) + order = g_new (gint, g_sequence_get_length (store->seq)); + for (i = 0; i < g_sequence_get_length (store->seq); i++) order[new_order[i]] = i; new_positions = g_hash_table_new (g_direct_hash, g_direct_equal); - ptr = _gtk_sequence_get_begin_ptr (store->seq); + ptr = g_sequence_get_begin_iter (store->seq); i = 0; - while (!_gtk_sequence_ptr_is_end (ptr)) + while (!g_sequence_iter_is_end (ptr)) { g_hash_table_insert (new_positions, ptr, GINT_TO_POINTER (order[i++])); - ptr = _gtk_sequence_ptr_next (ptr); + ptr = g_sequence_iter_next (ptr); } g_free (order); - _gtk_sequence_sort (store->seq, gtk_list_store_reorder_func, new_positions); + g_sequence_sort_iter (store->seq, gtk_list_store_reorder_func, new_positions); g_hash_table_destroy (new_positions); @@ -1365,37 +1364,37 @@ gtk_list_store_reorder (GtkListStore *store, } static GHashTable * -save_positions (GtkSequence *seq) +save_positions (GSequence *seq) { GHashTable *positions = g_hash_table_new (g_direct_hash, g_direct_equal); - GtkSequencePtr ptr; + GSequenceIter *ptr; - ptr = _gtk_sequence_get_begin_ptr (seq); - while (!_gtk_sequence_ptr_is_end (ptr)) + ptr = g_sequence_get_begin_iter (seq); + while (!g_sequence_iter_is_end (ptr)) { g_hash_table_insert (positions, ptr, - GINT_TO_POINTER (_gtk_sequence_ptr_get_position (ptr))); - ptr = _gtk_sequence_ptr_next (ptr); + GINT_TO_POINTER (g_sequence_iter_get_position (ptr))); + ptr = g_sequence_iter_next (ptr); } return positions; } static int * -generate_order (GtkSequence *seq, +generate_order (GSequence *seq, GHashTable *old_positions) { - GtkSequencePtr ptr; - int *order = g_new (int, _gtk_sequence_get_length (seq)); + GSequenceIter *ptr; + int *order = g_new (int, g_sequence_get_length (seq)); int i; i = 0; - ptr = _gtk_sequence_get_begin_ptr (seq); - while (!_gtk_sequence_ptr_is_end (ptr)) + ptr = g_sequence_get_begin_iter (seq); + while (!g_sequence_iter_is_end (ptr)) { int old_pos = GPOINTER_TO_INT (g_hash_table_lookup (old_positions, ptr)); order[i++] = old_pos; - ptr = _gtk_sequence_ptr_next (ptr); + ptr = g_sequence_iter_next (ptr); } g_hash_table_destroy (old_positions); @@ -1433,7 +1432,7 @@ gtk_list_store_swap (GtkListStore *store, old_positions = save_positions (store->seq); - _gtk_sequence_swap (a->user_data, b->user_data); + g_sequence_swap (a->user_data, b->user_data); order = generate_order (store->seq, old_positions); path = gtk_tree_path_new (); @@ -1456,7 +1455,7 @@ gtk_list_store_move_to (GtkListStore *store, old_positions = save_positions (store->seq); - _gtk_sequence_move (iter->user_data, _gtk_sequence_get_ptr_at_pos (store->seq, new_pos)); + g_sequence_move (iter->user_data, g_sequence_get_iter_at_pos (store->seq, new_pos)); order = generate_order (store->seq, old_positions); @@ -1493,7 +1492,7 @@ gtk_list_store_move_before (GtkListStore *store, g_return_if_fail (VALID_ITER (position, store)); if (position) - pos = _gtk_sequence_ptr_get_position (position->user_data); + pos = g_sequence_iter_get_position (position->user_data); else pos = -1; @@ -1526,7 +1525,7 @@ gtk_list_store_move_after (GtkListStore *store, g_return_if_fail (VALID_ITER (position, store)); if (position) - pos = _gtk_sequence_ptr_get_position (position->user_data) + 1; + pos = g_sequence_iter_get_position (position->user_data) + 1; else pos = 0; @@ -1594,12 +1593,12 @@ gtk_list_store_sort (GtkListStore *list_store) GHashTable *old_positions; if (!GTK_LIST_STORE_IS_SORTED (list_store) || - _gtk_sequence_get_length (list_store->seq) <= 1) + g_sequence_get_length (list_store->seq) <= 1) return; old_positions = save_positions (list_store->seq); - _gtk_sequence_sort (list_store->seq, gtk_list_store_compare_func, list_store); + g_sequence_sort_iter (list_store->seq, gtk_list_store_compare_func, list_store); /* Let the world know about our new order */ new_order = generate_order (list_store->seq, old_positions); @@ -1615,17 +1614,17 @@ static gboolean iter_is_sorted (GtkListStore *list_store, GtkTreeIter *iter) { - GtkSequencePtr cmp; + GSequenceIter *cmp; - if (!_gtk_sequence_ptr_is_begin (iter->user_data)) + if (!g_sequence_iter_is_begin (iter->user_data)) { - cmp = _gtk_sequence_ptr_prev (iter->user_data); + cmp = g_sequence_iter_prev (iter->user_data); if (gtk_list_store_compare_func (cmp, iter->user_data, list_store) > 0) return FALSE; } - cmp = _gtk_sequence_ptr_next (iter->user_data); - if (!_gtk_sequence_ptr_is_end (cmp)) + cmp = g_sequence_iter_next (iter->user_data); + if (!g_sequence_iter_is_end (cmp)) { if (gtk_list_store_compare_func (iter->user_data, cmp, list_store) > 0) return FALSE; @@ -1652,9 +1651,9 @@ gtk_list_store_sort_iter_changed (GtkListStore *list_store, gint *order; old_positions = save_positions (list_store->seq); - _gtk_sequence_sort_changed (iter->user_data, - gtk_list_store_compare_func, - list_store); + g_sequence_sort_changed_iter (iter->user_data, + gtk_list_store_compare_func, + list_store); order = generate_order (list_store->seq, old_positions); path = gtk_tree_path_new (); gtk_tree_model_rows_reordered (GTK_TREE_MODEL (list_store), @@ -1807,8 +1806,8 @@ gtk_list_store_insert_with_values (GtkListStore *list_store, ...) { GtkTreePath *path; - GtkSequence *seq; - GtkSequencePtr ptr; + GSequence *seq; + GSequenceIter *ptr; GtkTreeIter tmp_iter; gint length; gboolean changed = FALSE; @@ -1825,12 +1824,12 @@ gtk_list_store_insert_with_values (GtkListStore *list_store, seq = list_store->seq; - length = _gtk_sequence_get_length (seq); + length = g_sequence_get_length (seq); if (position > length) position = length; - ptr = _gtk_sequence_get_ptr_at_pos (seq, position); - ptr = _gtk_sequence_insert (ptr, NULL); + ptr = g_sequence_get_iter_at_pos (seq, position); + ptr = g_sequence_insert_before (ptr, NULL); iter->stamp = list_store->stamp; iter->user_data = ptr; @@ -1847,9 +1846,9 @@ gtk_list_store_insert_with_values (GtkListStore *list_store, /* Don't emit rows_reordered here */ if (maybe_need_sort && GTK_LIST_STORE_IS_SORTED (list_store)) - _gtk_sequence_sort_changed (iter->user_data, - gtk_list_store_compare_func, - list_store); + g_sequence_sort_changed_iter (iter->user_data, + gtk_list_store_compare_func, + list_store); /* Just emit row_inserted */ path = gtk_list_store_get_path (GTK_TREE_MODEL (list_store), iter); @@ -1883,8 +1882,8 @@ gtk_list_store_insert_with_valuesv (GtkListStore *list_store, gint n_values) { GtkTreePath *path; - GtkSequence *seq; - GtkSequencePtr ptr; + GSequence *seq; + GSequenceIter *ptr; GtkTreeIter tmp_iter; gint length; gboolean changed = FALSE; @@ -1904,12 +1903,12 @@ gtk_list_store_insert_with_valuesv (GtkListStore *list_store, seq = list_store->seq; - length = _gtk_sequence_get_length (seq); + length = g_sequence_get_length (seq); if (position > length) position = length; - ptr = _gtk_sequence_get_ptr_at_pos (seq, position); - ptr = _gtk_sequence_insert (ptr, NULL); + ptr = g_sequence_get_iter_at_pos (seq, position); + ptr = g_sequence_insert_before (ptr, NULL); iter->stamp = list_store->stamp; iter->user_data = ptr; @@ -1937,9 +1936,9 @@ gtk_list_store_insert_with_valuesv (GtkListStore *list_store, /* Don't emit rows_reordered here */ if (maybe_need_sort && GTK_LIST_STORE_IS_SORTED (list_store)) - _gtk_sequence_sort_changed (iter->user_data, - gtk_list_store_compare_func, - list_store); + g_sequence_sort_changed_iter (iter->user_data, + gtk_list_store_compare_func, + list_store); /* Just emit row_inserted */ path = gtk_list_store_get_path (GTK_TREE_MODEL (list_store), iter); diff --git a/gtk/gtksequence.c b/gtk/gtksequence.c deleted file mode 100644 index 64e3784b01..0000000000 --- a/gtk/gtksequence.c +++ /dev/null @@ -1,1143 +0,0 @@ -/* GLIB - Library of useful routines for C programming - * Copyright (C) 2002 Soeren Sandmann (sandmann@daimi.au.dk) - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the - * Free Software Foundation, Inc., 59 Temple Place - Suite 330, - * Boston, MA 02111-1307, USA. - */ - -#include - -#include "gtksequence.h" -#include "gtkalias.h" - -typedef struct _GtkSequenceNode GtkSequenceNode; - -struct _GtkSequence { - GtkSequenceNode *node; /* does not necessarily point to the root. - * You can splay it if you want it to - */ - GDestroyNotify data_destroy_notify; -}; - -struct _GtkSequenceNode { - guint is_end : 1; - gint n_nodes : 31; /* number of nodes below this node, - * including this node - */ - GtkSequenceNode *parent; - GtkSequenceNode *left; - GtkSequenceNode *right; - - GtkSequence *sequence; - - gpointer data; -}; - -static GtkSequenceNode *_gtk_sequence_node_new (gpointer data); -static GtkSequenceNode *_gtk_sequence_node_find_first (GtkSequenceNode *node); -static GtkSequenceNode *_gtk_sequence_node_find_last (GtkSequenceNode *node); -static GtkSequenceNode *_gtk_sequence_node_find_by_pos (GtkSequenceNode *node, - gint pos); -static GtkSequenceNode *_gtk_sequence_node_prev (GtkSequenceNode *node); -static GtkSequenceNode *_gtk_sequence_node_next (GtkSequenceNode *node); -static gint _gtk_sequence_node_get_pos (GtkSequenceNode *node); -static GtkSequence *_gtk_sequence_node_get_sequence (GtkSequenceNode *node); -static GtkSequenceNode *_gtk_sequence_node_find_closest (GtkSequenceNode *node, - GtkSequenceNode *other, - GCompareDataFunc cmp, - gpointer data); -static gint _gtk_sequence_node_get_length (GtkSequenceNode *node); -static void _gtk_sequence_node_free (GtkSequenceNode *node, - GDestroyNotify destroy); -#if 0 -static gboolean _gtk_sequence_node_is_singleton (GtkSequenceNode *node); -#endif -static void _gtk_sequence_node_split (GtkSequenceNode *node, - GtkSequenceNode **left, - GtkSequenceNode **right); -static void _gtk_sequence_node_insert_before (GtkSequenceNode *node, - GtkSequenceNode *new); -static void _gtk_sequence_node_remove (GtkSequenceNode *node); -static void _gtk_sequence_node_insert_sorted (GtkSequenceNode *node, - GtkSequenceNode *new, - GCompareDataFunc cmp_func, - gpointer cmp_data); - -/* GtkSequence */ -GtkSequence * -_gtk_sequence_new (GDestroyNotify data_destroy) -{ - GtkSequence *seq = g_new (GtkSequence, 1); - seq->data_destroy_notify = data_destroy; - - seq->node = _gtk_sequence_node_new (NULL); - seq->node->is_end = TRUE; - seq->node->sequence = seq; - - return seq; -} - -void -_gtk_sequence_foreach (GtkSequence *seq, - GFunc func, - gpointer data) -{ - GtkSequencePtr ptr; - - g_return_if_fail (seq != NULL); - g_return_if_fail (func != NULL); - - ptr = _gtk_sequence_get_begin_ptr (seq); - - while (!_gtk_sequence_ptr_is_end (ptr)) - { - GtkSequenceNode *node = ptr; - - func (node->data, data); - - ptr = _gtk_sequence_ptr_next (ptr); - } - -} - -void -_gtk_sequence_free (GtkSequence *seq) -{ - g_return_if_fail (seq != NULL); - - _gtk_sequence_node_free (seq->node, seq->data_destroy_notify); - - g_free (seq); -} - -#if 0 -static void -flatten_nodes (GtkSequenceNode *node, GList **list) -{ - g_print ("flatten %p\n", node); - if (!node) - return; - else if (_gtk_sequence_node_is_singleton (node)) - *list = g_list_prepend (*list, node); - else - { - GtkSequenceNode *left; - GtkSequenceNode *right; - - _gtk_sequence_node_split (node, &left, &right); - - flatten_nodes (left, list); - flatten_nodes (right, list); - } -} -#endif - -typedef struct SortInfo SortInfo; -struct SortInfo { - GCompareDataFunc cmp; - gpointer data; -}; - -static gint -node_compare (gconstpointer n1, gconstpointer n2, gpointer data) -{ - const SortInfo *info = data; - const GtkSequenceNode *node1 = n1; - const GtkSequenceNode *node2 = n2; - gint retval; - - if (node1->is_end) - return 1; - - if (node2->is_end) - return -1; - - retval = (* info->cmp) (node1, node2, info->data); - - /* If the nodes are different, but the user-supplied compare function - * compares them equal, then force an arbitrary (but consistent) order - * on them, so that our sorts will be stable - */ - if (retval != 0 || n1 == n2) - return retval; - - if (n1 > n2) - return 1; - else - return -1; -} - -void -_gtk_sequence_append (GtkSequence *seq, - gpointer data) -{ - GtkSequenceNode *node, *last; - - g_return_if_fail (seq != NULL); - - node = _gtk_sequence_node_new (data); - node->sequence = seq; - last = _gtk_sequence_node_find_last (seq->node); - _gtk_sequence_node_insert_before (last, node); -} -#if 0 - -void -_gtk_sequence_prepend (GtkSequence *seq, - gpointer data) -{ - GtkSequenceNode *node, *second; - - g_return_if_fail (seq != NULL); - - node = _gtk_sequence_node_new (data); - node->sequence = seq; - second = _gtk_sequence_node_next (_gtk_sequence_node_find_first (seq->node)); - - _gtk_sequence_node_insert_before (second, node); -} -#endif - -GtkSequencePtr -_gtk_sequence_insert (GtkSequencePtr ptr, - gpointer data) -{ - GtkSequenceNode *node; - - g_return_val_if_fail (ptr != NULL, NULL); - - node = _gtk_sequence_node_new (data); - node->sequence = ptr->sequence; - - _gtk_sequence_node_insert_before (ptr, node); - - return node; -} - -static void -_gtk_sequence_unlink (GtkSequence *seq, - GtkSequenceNode *node) -{ - g_assert (!node->is_end); - - seq->node = _gtk_sequence_node_next (node); - - g_assert (seq->node); - g_assert (seq->node != node); - - _gtk_sequence_node_remove (node); -} - -void -_gtk_sequence_remove (GtkSequencePtr ptr) -{ - GtkSequence *seq; - - g_return_if_fail (ptr != NULL); - g_return_if_fail (!ptr->is_end); - - seq = _gtk_sequence_node_get_sequence (ptr); - _gtk_sequence_unlink (seq, ptr); - _gtk_sequence_node_free (ptr, seq->data_destroy_notify); -} - -void -_gtk_sequence_sort (GtkSequence *seq, - GCompareDataFunc cmp_func, - gpointer cmp_data) -{ - GtkSequence *tmp; - GtkSequenceNode *begin, *end; - - g_return_if_fail (seq != NULL); - g_return_if_fail (cmp_func != NULL); - - begin = _gtk_sequence_get_begin_ptr (seq); - end = _gtk_sequence_get_end_ptr (seq); - - _gtk_sequence_remove_range (begin, end, &tmp); - - while (_gtk_sequence_get_length (tmp) > 0) - { - GtkSequenceNode *node = _gtk_sequence_get_begin_ptr (tmp); - _gtk_sequence_unlink (tmp, node); - - _gtk_sequence_node_insert_sorted (seq->node, node, cmp_func, cmp_data); - } - - _gtk_sequence_free (tmp); -} - -gpointer -_gtk_sequence_ptr_get_data (GtkSequencePtr ptr) -{ - g_return_val_if_fail (ptr != NULL, NULL); - g_return_val_if_fail (!ptr->is_end, NULL); - - return ptr->data; -} - -GtkSequencePtr -_gtk_sequence_insert_sorted (GtkSequence *seq, - gpointer data, - GCompareDataFunc cmp_func, - gpointer cmp_data) -{ - GtkSequenceNode *new_node = _gtk_sequence_node_new (data); - new_node->sequence = seq; - _gtk_sequence_node_insert_sorted (seq->node, new_node, cmp_func, cmp_data); - return new_node; -} - -void -_gtk_sequence_insert_sequence (GtkSequencePtr ptr, - GtkSequence *other_seq) -{ - GtkSequenceNode *last; - - g_return_if_fail (other_seq != NULL); - g_return_if_fail (ptr != NULL); - - last = _gtk_sequence_node_find_last (other_seq->node); - _gtk_sequence_node_insert_before (ptr, last); - _gtk_sequence_node_remove (last); - _gtk_sequence_node_free (last, NULL); - other_seq->node = NULL; - _gtk_sequence_free (other_seq); -} - -void -_gtk_sequence_concatenate (GtkSequence *seq1, - GtkSequence *seq2) -{ - GtkSequenceNode *last; - - g_return_if_fail (seq1 != NULL); - g_return_if_fail (seq2 != NULL); - - last = _gtk_sequence_node_find_last (seq1->node); - _gtk_sequence_insert_sequence (last, seq2); -} - -/* - * The new sequence inherits the destroy notify from the sequence that - * beign and end comes from - */ -void -_gtk_sequence_remove_range (GtkSequencePtr begin, - GtkSequencePtr end, - GtkSequence **removed) -{ - GtkSequence *seq; - GtkSequenceNode *s1, *s2, *s3; - - seq = _gtk_sequence_node_get_sequence (begin); - - g_assert (end != NULL); - - g_return_if_fail (seq == _gtk_sequence_node_get_sequence (end)); - - _gtk_sequence_node_split (begin, &s1, &s2); - _gtk_sequence_node_split (end, NULL, &s3); - - if (s1) - _gtk_sequence_node_insert_before (s3, s1); - - seq->node = s3; - - if (removed) - { - *removed = _gtk_sequence_new (seq->data_destroy_notify); - _gtk_sequence_node_insert_before ((*removed)->node, s2); - } - else - { - _gtk_sequence_node_free (s2, seq->data_destroy_notify); - } -} - -gint -_gtk_sequence_get_length (GtkSequence *seq) -{ - return _gtk_sequence_node_get_length (seq->node) - 1; -} - -GtkSequencePtr -_gtk_sequence_get_end_ptr (GtkSequence *seq) -{ - g_return_val_if_fail (seq != NULL, NULL); - return _gtk_sequence_node_find_last (seq->node); -} - -GtkSequencePtr -_gtk_sequence_get_begin_ptr (GtkSequence *seq) -{ - g_return_val_if_fail (seq != NULL, NULL); - return _gtk_sequence_node_find_first (seq->node); -} - -/* - * if pos > number of items or -1, will return end pointer - */ -GtkSequencePtr -_gtk_sequence_get_ptr_at_pos (GtkSequence *seq, - gint pos) -{ - gint len; - - g_return_val_if_fail (seq != NULL, NULL); - - len = _gtk_sequence_get_length (seq); - - if (pos > len || pos == -1) - pos = len; - - return _gtk_sequence_node_find_by_pos (seq->node, pos); -} - - -/* GtkSequencePtr */ -gboolean -_gtk_sequence_ptr_is_end (GtkSequencePtr ptr) -{ - g_return_val_if_fail (ptr != NULL, FALSE); - return ptr->is_end; -} - -gboolean -_gtk_sequence_ptr_is_begin (GtkSequencePtr ptr) -{ - return (_gtk_sequence_node_prev (ptr) == ptr); -} - -/* If you call this on an end pointer you'll get - * the length of the sequence - */ -gint -_gtk_sequence_ptr_get_position (GtkSequencePtr ptr) -{ - g_return_val_if_fail (ptr != NULL, -1); - - return _gtk_sequence_node_get_pos (ptr); -} - -GtkSequencePtr -_gtk_sequence_ptr_next (GtkSequencePtr ptr) -{ - g_return_val_if_fail (ptr != NULL, NULL); - - return _gtk_sequence_node_next (ptr); -} - -GtkSequencePtr -_gtk_sequence_ptr_prev (GtkSequencePtr ptr) -{ - g_return_val_if_fail (ptr != NULL, NULL); - - return _gtk_sequence_node_prev (ptr); -} - -GtkSequencePtr -_gtk_sequence_ptr_move (GtkSequencePtr ptr, - guint delta) -{ - gint new_pos; - - g_return_val_if_fail (ptr != NULL, NULL); - - new_pos = _gtk_sequence_node_get_pos (ptr) + delta; - - return _gtk_sequence_node_find_by_pos (ptr, new_pos); -} - -void -_gtk_sequence_sort_changed (GtkSequencePtr ptr, - GCompareDataFunc cmp_func, - gpointer cmp_data) - -{ - GtkSequence *seq; - - g_return_if_fail (ptr != NULL); - g_return_if_fail (!ptr->is_end); - - seq = _gtk_sequence_node_get_sequence (ptr); - _gtk_sequence_unlink (seq, ptr); - _gtk_sequence_node_insert_sorted (seq->node, ptr, cmp_func, cmp_data); -} - -/* search - * - * The only restriction on the search function is that it - * must not delete any nodes. It is permitted to insert new nodes, - * but the caller should "know what he is doing" - */ -void -_gtk_sequence_search (GtkSequence *seq, - GtkSequenceSearchFunc f, - gpointer data) -{ - GQueue *intervals = g_queue_new (); - - g_queue_push_tail (intervals, _gtk_sequence_node_find_first (seq->node)); - g_queue_push_tail (intervals, _gtk_sequence_node_find_last (seq->node)); - - while (!g_queue_is_empty (intervals)) - { - GtkSequenceNode *begin = g_queue_pop_head (intervals); - GtkSequenceNode *end = g_queue_pop_head (intervals); - - if (f (begin, end, data)) - { - gint begin_pos = _gtk_sequence_node_get_pos (begin); - gint end_pos = _gtk_sequence_node_get_pos (end); - - if (end_pos - begin_pos > 1) - { - GtkSequenceNode *mid; - gint mid_pos; - - mid_pos = begin_pos + (end_pos - begin_pos) / 2; - mid = _gtk_sequence_node_find_by_pos (begin, mid_pos); - - g_queue_push_tail (intervals, begin); - g_queue_push_tail (intervals, mid); - - g_queue_push_tail (intervals, mid); - g_queue_push_tail (intervals, end); - } - } - } - - g_queue_free (intervals); -} - -#if 0 -/* aggregates */ -void -_gtk_sequence_add_aggregate (GtkSequence *seq, - const gchar *aggregate, - GtkSequenceAggregateFunc f, - gpointer data, - GDestroyNotify destroy) -{ - /* FIXME */ -} - -void -_gtk_sequence_remove_aggregate (GtkSequence *seq, - const gchar aggregate) -{ - /* FIXME */ - -} - -void -_gtk_sequence_set_aggregate_data (GtkSequencePtr ptr, - const gchar *aggregate, - gpointer data) -{ - /* FIXME */ - -} - -gpointer -_gtk_sequence_get_aggregate_data (GtkSequencePtr begin, - GtkSequencePtr end, - const gchar *aggregate) -{ - g_assert_not_reached(); - return NULL; -} -#endif - - -/* Nodes - */ -static void -_gtk_sequence_node_update_fields (GtkSequenceNode *node) -{ - g_assert (node != NULL); - - node->n_nodes = 1; - - if (node->left) - node->n_nodes += node->left->n_nodes; - - if (node->right) - node->n_nodes += node->right->n_nodes; - -#if 0 - if (node->left || node->right) - g_assert (node->n_nodes > 1); -#endif -} - -#define NODE_LEFT_CHILD(n) (((n)->parent) && ((n)->parent->left) == (n)) -#define NODE_RIGHT_CHILD(n) (((n)->parent) && ((n)->parent->right) == (n)) - -static void -_gtk_sequence_node_rotate (GtkSequenceNode *node) -{ - GtkSequenceNode *tmp, *old; - - g_assert (node->parent); - g_assert (node->parent != node); - - if (NODE_LEFT_CHILD (node)) - { - /* rotate right */ - tmp = node->right; - - node->right = node->parent; - node->parent = node->parent->parent; - if (node->parent) - { - if (node->parent->left == node->right) - node->parent->left = node; - else - node->parent->right = node; - } - - g_assert (node->right); - - node->right->parent = node; - node->right->left = tmp; - - if (node->right->left) - node->right->left->parent = node->right; - - old = node->right; - } - else - { - /* rotate left */ - tmp = node->left; - - node->left = node->parent; - node->parent = node->parent->parent; - if (node->parent) - { - if (node->parent->right == node->left) - node->parent->right = node; - else - node->parent->left = node; - } - - g_assert (node->left); - - node->left->parent = node; - node->left->right = tmp; - - if (node->left->right) - node->left->right->parent = node->left; - - old = node->left; - } - - _gtk_sequence_node_update_fields (old); - _gtk_sequence_node_update_fields (node); -} - -static GtkSequenceNode * -splay (GtkSequenceNode *node) -{ - while (node->parent) - { - if (!node->parent->parent) - { - /* zig */ - _gtk_sequence_node_rotate (node); - } - else if ((NODE_LEFT_CHILD (node) && NODE_LEFT_CHILD (node->parent)) || - (NODE_RIGHT_CHILD (node) && NODE_RIGHT_CHILD (node->parent))) - { - /* zig-zig */ - _gtk_sequence_node_rotate (node->parent); - _gtk_sequence_node_rotate (node); - } - else - { - /* zig-zag */ - _gtk_sequence_node_rotate (node); - _gtk_sequence_node_rotate (node); - } - } - - return node; -} - -static GtkSequenceNode * -_gtk_sequence_node_new (gpointer data) -{ - GtkSequenceNode *node = g_new0 (GtkSequenceNode, 1); - - node->parent = NULL; - node->left = NULL; - node->right = NULL; - - node->data = data; - node->is_end = FALSE; - node->n_nodes = 1; - - return node; -} - -static GtkSequenceNode * -find_min (GtkSequenceNode *node) -{ - splay (node); - - while (node->left) - node = node->left; - - return node; -} - -static GtkSequenceNode * -find_max (GtkSequenceNode *node) -{ - splay (node); - - while (node->right) - node = node->right; - - return node; -} - -static GtkSequenceNode * -_gtk_sequence_node_find_first (GtkSequenceNode *node) -{ - return splay (find_min (node)); -} - -static GtkSequenceNode * -_gtk_sequence_node_find_last (GtkSequenceNode *node) -{ - return splay (find_max (node)); -} - -static gint -get_n_nodes (GtkSequenceNode *node) -{ - if (node) - return node->n_nodes; - else - return 0; -} - -static GtkSequenceNode * -_gtk_sequence_node_find_by_pos (GtkSequenceNode *node, - gint pos) -{ - gint i; - - g_assert (node != NULL); - - splay (node); - - while ((i = get_n_nodes (node->left)) != pos) - { - if (i < pos) - { - node = node->right; - pos -= (i + 1); - } - else - { - node = node->left; - g_assert (node->parent != NULL); - } - } - - return splay (node); -} - -static GtkSequenceNode * -_gtk_sequence_node_prev (GtkSequenceNode *node) -{ - splay (node); - - if (node->left) - { - node = node->left; - while (node->right) - node = node->right; - } - - return splay (node); -} - -static GtkSequenceNode * -_gtk_sequence_node_next (GtkSequenceNode *node) -{ - splay (node); - - if (node->right) - { - node = node->right; - while (node->left) - node = node->left; - } - - return splay (node); -} - -static gint -_gtk_sequence_node_get_pos (GtkSequenceNode *node) -{ - splay (node); - - return get_n_nodes (node->left); -} - -static GtkSequence * -_gtk_sequence_node_get_sequence (GtkSequenceNode *node) -{ - splay (node); - - return node->sequence; -} - -static GtkSequenceNode * -_gtk_sequence_node_find_closest (GtkSequenceNode *node, - GtkSequenceNode *other, - GCompareDataFunc cmp, - gpointer data) -{ - GtkSequenceNode *best; - gint c; - - splay (node); - - do - { - best = node; - - if ((c = cmp (node, other, data)) != 0) - { - if (c < 0) - node = node->right; - else - node = node->left; - } - } - while (c != 0 && node != NULL); - - return best; -} - -static void -_gtk_sequence_node_free (GtkSequenceNode *node, - GDestroyNotify destroy) -{ - /* FIXME: - * - * This is to avoid excessively deep recursions. A splay tree is not necessarily - * balanced at all. - * - * I _think_ this is still linear in the number of nodes, but I'd like to - * do something more efficient. - */ - - while (node) - { - GtkSequenceNode *next; - - node = splay (find_min (node)); - next = node->right; - if (next) - next->parent = NULL; - - if (destroy && !node->is_end) - destroy (node->data); - g_free (node); - - node = next; - } -} - -#if 0 -static gboolean -_gtk_sequence_node_is_singleton (GtkSequenceNode *node) -{ - splay (node); - - if (node->left || node->right) - return FALSE; - - return TRUE; -} -#endif - -static void -_gtk_sequence_node_split (GtkSequenceNode *node, - GtkSequenceNode **left, - GtkSequenceNode **right) -{ - GtkSequenceNode *left_tree; - - splay (node); - - left_tree = node->left; - if (left_tree) - { - left_tree->parent = NULL; - _gtk_sequence_node_update_fields (left_tree); - } - - node->left = NULL; - _gtk_sequence_node_update_fields (node); - - if (left) - *left = left_tree; - - if (right) - *right = node; -} - -static void -_gtk_sequence_node_insert_before (GtkSequenceNode *node, - GtkSequenceNode *new) -{ - g_assert (node != NULL); - g_assert (new != NULL); - - splay (node); - - new = splay (find_min (new)); - g_assert (new->left == NULL); - - if (node->left) - node->left->parent = new; - - new->left = node->left; - new->parent = node; - - node->left = new; - - _gtk_sequence_node_update_fields (new); - _gtk_sequence_node_update_fields (node); -} - -static gint -_gtk_sequence_node_get_length (GtkSequenceNode *node) -{ - g_assert (node != NULL); - - splay (node); - return node->n_nodes; -} - -static void -_gtk_sequence_node_remove (GtkSequenceNode *node) -{ - GtkSequenceNode *right, *left; - - splay (node); - - left = node->left; - right = node->right; - - node->left = node->right = NULL; - - if (right) - { - right->parent = NULL; - - right = _gtk_sequence_node_find_first (right); - g_assert (right->left == NULL); - - right->left = left; - if (left) - { - left->parent = right; - _gtk_sequence_node_update_fields (right); - } - } - else if (left) - left->parent = NULL; -} - -#if 0 -/* debug func */ -static gint -_gtk_sequence_node_calc_height (GtkSequenceNode *node) -{ - /* breadth first traversal */ - gint height = 0; - GQueue *nodes = g_queue_new (); - - g_queue_push_tail (nodes, node); - - while (!g_queue_is_empty (nodes)) - { - GQueue *tmp = g_queue_new (); - - height++; - while (!g_queue_is_empty (nodes)) - { - GtkSequenceNode *node = g_queue_pop_head (nodes); - if (node->left) - g_queue_push_tail (tmp, node->left); - if (node->right) - g_queue_push_tail (tmp, node->right); - } - - g_queue_free (nodes); - - nodes = tmp; - } - g_queue_free (nodes); - - return height; -} -#endif - -static void -_gtk_sequence_node_insert_sorted (GtkSequenceNode *node, - GtkSequenceNode *new, - GCompareDataFunc cmp_func, - gpointer cmp_data) -{ - SortInfo info; - GtkSequenceNode *closest; - info.cmp = cmp_func; - info.data = cmp_data; - - closest = - _gtk_sequence_node_find_closest (node, new, node_compare, &info); - - g_assert (closest != new); - - if (node_compare (new, closest, &info) > 0) - closest = _gtk_sequence_node_next (closest); - - _gtk_sequence_node_insert_before (closest, new); -} - -static gint -_gtk_sequence_node_calc_height (GtkSequenceNode *node) -{ - gint left_height; - gint right_height; - - if (node) - { - left_height = 0; - right_height = 0; - - if (node->left) - left_height = _gtk_sequence_node_calc_height (node->left); - - if (node->right) - right_height = _gtk_sequence_node_calc_height (node->right); - - return MAX (left_height, right_height) + 1; - } - - return 0; -} - -gint -_gtk_sequence_calc_tree_height (GtkSequence *seq) -{ - GtkSequenceNode *node = seq->node; - gint r, l; - while (node->parent) - node = node->parent; - - if (node) - { - r = _gtk_sequence_node_calc_height (node->right); - l = _gtk_sequence_node_calc_height (node->left); - - return MAX (r, l) + 1; - } - else - return 0; -} - -GtkSequence * -_gtk_sequence_ptr_get_sequence (GtkSequencePtr ptr) -{ - GtkSequenceNode *node = ptr; - - return node->sequence; -} - -void -_gtk_sequence_swap (GtkSequencePtr a, - GtkSequencePtr b) -{ - GtkSequenceNode *leftmost, *rightmost, *rightmost_next; - int a_pos, b_pos; - - g_return_if_fail (!_gtk_sequence_ptr_is_end (a)); - g_return_if_fail (!_gtk_sequence_ptr_is_end (b)); - - if (a == b) - return; - - a_pos = _gtk_sequence_ptr_get_position (a); - b_pos = _gtk_sequence_ptr_get_position (b); - - if (a_pos > b_pos) - { - leftmost = b; - rightmost = a; - } - else - { - leftmost = a; - rightmost = b; - } - - rightmost_next = _gtk_sequence_node_next (rightmost); - - /* Situation now: ..., leftmost, ......., rightmost, rightmost_next, ... */ - - _gtk_sequence_move (rightmost, leftmost); - _gtk_sequence_move (leftmost, rightmost_next); -} - -void -_gtk_sequence_move (GtkSequencePtr ptr, - GtkSequencePtr new_pos) -{ - g_return_if_fail (ptr != NULL); - g_return_if_fail (new_pos != NULL); - - if (ptr == new_pos) - return; - - _gtk_sequence_unlink (ptr->sequence, ptr); - _gtk_sequence_node_insert_before (new_pos, ptr); -} - -/* Overwrites the existing pointer. */ -void -_gtk_sequence_set (GtkSequencePtr ptr, - gpointer data) -{ - GtkSequence *seq; - - g_return_if_fail (!_gtk_sequence_ptr_is_end (ptr)); - - seq = _gtk_sequence_node_get_sequence (ptr); - if (seq->data_destroy_notify) - seq->data_destroy_notify (ptr->data); - ptr->data = data; -} diff --git a/gtk/gtksequence.h b/gtk/gtksequence.h deleted file mode 100644 index a61cf5aed4..0000000000 --- a/gtk/gtksequence.h +++ /dev/null @@ -1,104 +0,0 @@ -/* GLIB - Library of useful routines for C programming - * Copyright (C) 2002 Soeren Sandmann (sandmann@daimi.au.dk) - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the - * Free Software Foundation, Inc., 59 Temple Place - Suite 330, - * Boston, MA 02111-1307, USA. - */ - -#include - -#ifndef __GSEQUENCE_H__ -#define __GSEQUENCE_H__ - - -/* Warning - * - * Do not use this API. It is here, internal to gtk+, for 2.6 only. - * In 2.8 the plan is to add a similar data structure to GLib. - */ - -typedef struct _GtkSequence GtkSequence; -typedef struct _GtkSequenceNode *GtkSequencePtr; - -/* GtkSequence */ -GtkSequence * _gtk_sequence_new (GDestroyNotify data_destroy); -void _gtk_sequence_free (GtkSequence *seq); -void _gtk_sequence_sort (GtkSequence *seq, - GCompareDataFunc cmp_func, - gpointer cmp_data); -void _gtk_sequence_append (GtkSequence *seq, - gpointer data); -void _gtk_sequence_prepend (GtkSequence *seq, - gpointer data); -GtkSequencePtr _gtk_sequence_insert (GtkSequencePtr ptr, - gpointer data); -void _gtk_sequence_remove (GtkSequencePtr ptr); -void _gtk_sequence_move (GtkSequencePtr ptr, - GtkSequencePtr pos); -void _gtk_sequence_swap (GtkSequencePtr a, - GtkSequencePtr b); -GtkSequencePtr _gtk_sequence_insert_sorted (GtkSequence *seq, - gpointer data, - GCompareDataFunc cmp_func, - gpointer cmp_data); -void _gtk_sequence_set (GtkSequencePtr ptr, - gpointer data); -void _gtk_sequence_insert_sequence (GtkSequencePtr ptr, - GtkSequence *other_seq); -void _gtk_sequence_concatenate (GtkSequence *seq1, - GtkSequence *seq); -void _gtk_sequence_remove_range (GtkSequencePtr begin, - GtkSequencePtr end, - GtkSequence **removed); -gint _gtk_sequence_get_length (GtkSequence *seq); -GtkSequencePtr _gtk_sequence_get_end_ptr (GtkSequence *seq); -GtkSequencePtr _gtk_sequence_get_begin_ptr (GtkSequence *seq); -GtkSequencePtr _gtk_sequence_get_ptr_at_pos (GtkSequence *seq, - gint pos); -void _gtk_sequence_sort_changed (GtkSequencePtr ptr, - GCompareDataFunc cmp_func, - gpointer cmp_data); -void _gtk_sequence_foreach (GtkSequence *seq, - GFunc func, - gpointer data); - -/* GtkSequencePtr */ -gboolean _gtk_sequence_ptr_is_end (GtkSequencePtr ptr); -gboolean _gtk_sequence_ptr_is_begin (GtkSequencePtr ptr); -gint _gtk_sequence_ptr_get_position (GtkSequencePtr ptr); -GtkSequencePtr _gtk_sequence_ptr_next (GtkSequencePtr ptr); -GtkSequencePtr _gtk_sequence_ptr_prev (GtkSequencePtr ptr); -GtkSequencePtr _gtk_sequence_ptr_move (GtkSequencePtr ptr, - guint leap); -gpointer _gtk_sequence_ptr_get_data (GtkSequencePtr ptr); -GtkSequence *_gtk_sequence_ptr_get_sequence (GtkSequencePtr ptr); - -/* search */ - -/* return TRUE if you want to be called again with two - * smaller segments - */ -typedef gboolean (* GtkSequenceSearchFunc) (GtkSequencePtr begin, - GtkSequencePtr end, - gpointer data); - -void _gtk_sequence_search (GtkSequence *seq, - GtkSequenceSearchFunc f, - gpointer data); - -/* debug */ -gint _gtk_sequence_calc_tree_height (GtkSequence *seq); - -#endif /* __GSEQUENCE_H__ */ -- 2.30.2